import {FightBaseValueLevel, GameType, LogType} from "../type/Type";
import {AttributeEnum, AttrStrMap} from "../frame/dataSource/DataModel";

export enum ConfigKey {
    signalDurition,
    version,
    mode,
    saveMode,
    trackSkill,
    trackUnit,
    trackAttr,
    gameType,
    enemyTeam,
    maxEnemys,
    allyId,
    // 中立敌对
    neutralHostilityId,
    // 中立无敌意
    neutralInvincibility,
    clearItemTime,
    attackMonsterMaxNum,

    taskTipDurition,
    maxPetNum,
    maxItemSlot,
    maxGoodsBagNum,
    maxGoodsEquipNum,
    maxCombinationNum,
    maxHeroNum,
    attackMonsterNullTurnTime,
    attackMonsterTimerText,
    maxMainTask,
    maxTeamTask,
    maxDeputyTask,
    maxCirculateTask,
    maxForeverTask,

    storeLevel,
    uuidNum,
    flog,

    useGoodsBar,
    useTaskBar,
    useAchBar,
    usePetBar,
    useMultiBoradBar,
    useTalentBar,
    useChooseHeroBar,
    useAttrBar,
    useDamageBar,
    useCombination,
    useHandBook,
    useAppearance,
    useIntegralMall,
    useHideAch,
    useUnitAttrBar,
    useUnitShop,


    useBox,
    useQualityMix,
    // 使用物品栏装备部位检查
    usePositionCheck,
    petPatro,
    patrolRange,
    patrolTransRange,
    // 捕捉后自动跟随
    autoPetPatro,
    // 捕捉后自动召唤
    autoPetCall,
    // 召唤类型
    petCallType,
    // 死亡后自动复活
    petResumeType,
    // 超过距离传送
    outRangeMove,
    bindItemBlong,
    winDelay,
    failDelay,
    hentaiDifficulty,
    resumeTime,
    initheroAmount,
    waveAuto,
    baseTextSize,

    poison,
    poisonCardinal,
    poisonDivisor,
    poisonUsePercent,
    poisonEffectPoint,
    poisonEffect,

    startInNight,

    resumeTypes,
    autoResumeAll,
    resumeAllDelay,
    resumeAllTime,
    bossInterval,

    timeScale,
    dayStartTime,
    nightStartTime,
    dayNightTurn,

    levelUpInterval,

    chooseOneNum,
    diffRadixByPlayerNum,
    luckyRadixByPlayerNum,
    expRadixByPlayerNum,
    diffRadixByBossNum,

    removeFightTime,

    learnSkillByFamilyId,

    expRange,
    expType,
    attenuation,
    maxAttenuation,

    maxItemIndex,

    useBossRewardLoc,

    checkGameWinAlone,

    dropSpace,

    protection,
    clearUnitTime,

    resetGoodSuccess,
    resetGoodFailed,

    checkLoseTime,

    maxLowTimerExeNum,

    winScore,

    unitUseFamily,
    itemUseFamily,
    // 阶梯型的羁绊/套装效果
    unitUseLadder,
    itemUseLadder,
    maxUnitFamily,

    maxCombinationMemberNum,

    leaveFightReset,

    petDead,

    maxButtonNum,
    maxLevelUpNum,

    maxIntegral,

    showHurtNum,

    storeSplit,

    initCoin,
    initWood,
    initHeight,
    initAngle,

    resetAllUnit,

    useInputBackHome,
    useF2BackHome,
    useDSan,

    maxEncryptedLockKeyLen,

    reflushPath,
    reflushHatred,

    talkTaskRange,

    autoClearHurtNum,

    useDiffBar,

    useChatBar,

    autoShowAllHero,
    integralBase,

    engulfPetSkillRadix,

    maxUIShopNum,

    awaitWave,

    autoOpenDamage,
    autoOpenTask,

    initExp,
    expBase,
    sellItemRange,

    maxChatsLen,
    maxToastLen,

    cameraUnit,
    maxCameraHeight,
    minCameraHeight,
    showTimeDialog,
    syncInterval,

    maxArchiveNum,

    maxStoreNum,

    useLockKey,
    talentMaxNum,

    attrSetting,

    forgSetting,
    qualitySetting,
    washSetting,
    forgAddRadix,

    attackedEffectScale,

    callPetLvLimit,

    expAttenuation,
}

/**
 * null 是无论如何都不失败
 * default 是只有奖励失败才失败
 * noHero 是没有英雄存活时失败
 * moreMonster  是指进攻怪超过最大数量时失败
 */

export enum PetResumeType {
    null,
    default,
    home
}

export enum PetCallType {
    default,
    home
}

export enum ResumeType {
    null,
    autoResume,
    resumeAllInDay,
    UIResume,
}

export enum ExpShareType {
    share = 1,
    divide,
}


export enum GameWinAloneType {
    score = 1,
}

export interface AttrSetting {
    fightValue: FightBaseValueLevel,
    name: string,
    suffix: string,
}

export interface CosumeSetting {
    success: number,
    failed: number,
    cosumeId: string,
    cosumeNum: number,
}

export interface QualitySetting {
    name: string,
    mixNum: number,
    decomposeId: string,
    lvBox: string,
}

export interface ExpAttenuationSetting {
    [key: number]: number;
}


// 配置文件（每个项目配置文件可能不一致）
export class ConfigConstant {
    static [ConfigKey.version]: number = 0.08;

    // dev
    static [ConfigKey.mode]: number = LogType.product;

    // 保存的 模式的 日志
    static [ConfigKey.saveMode]: number;

    // dev
    static [ConfigKey.trackSkill]: string = 'boss21';

    // dev
    static [ConfigKey.trackUnit]: string = 'm906';

    // log中跟踪的属性
    static [ConfigKey.trackAttr]: AttributeEnum = AttributeEnum.attack;

    // 游戏类型  目前分为orpg与live
    // orpg中游戏开始弹出对话框让玩家读档或新建存档
    // live中游戏开始直接走进选择英雄的流程
    static [ConfigKey.gameType]: number = GameType.live;

    // 敌人的玩家队伍
    static [ConfigKey.enemyTeam] = 1;
    // 最大敌对单位数
    static [ConfigKey.maxEnemys] = 1000;
    // 盟友的玩家id
    static [ConfigKey.allyId] = 5;
    // 中立敌对 与 中立无敌意 的玩家Id
    static [ConfigKey.neutralHostilityId] = 12;
    static [ConfigKey.neutralInvincibility] = 15;
    // 自动清除物品的倒计时
    static [ConfigKey.clearItemTime] = 0;
    // -----------------------------------------------------------------------------------------------------------------------------------------------
    // 最大进攻怪数量(根据玩家数改变)
    static [ConfigKey.attackMonsterMaxNum] = [
        50,
        100,
        150,
        200,
        250,
        300,
        100
    ];

    // 任务小信号提示时间
    static [ConfigKey.taskTipDurition] = 5;


    // 最大宠物保存数
    static [ConfigKey.maxPetNum] = 10;


    // 物品栏最大数
    static [ConfigKey.maxItemSlot] = 6;

    // 包裹最大数
    static [ConfigKey.maxGoodsBagNum] = 30;

    // 装备栏最大数
    static [ConfigKey.maxGoodsEquipNum] = 10;

    // 羁绊最大数
    static [ConfigKey.maxCombinationNum] = 9;

    // ui选择英雄时 最大英雄数
    static [ConfigKey.maxHeroNum] = 30;

    // 出怪时 下一波怪物为空  计时器空转的间隔计时
    static [ConfigKey.attackMonsterNullTurnTime] = 3;

    // 出怪时 是否显示计时器
    static [ConfigKey.attackMonsterTimerText] = 1;


    // 每个玩家能接取的任务最大数
    static [ConfigKey.maxMainTask] = 0;
    static [ConfigKey.maxTeamTask] = 1;
    static [ConfigKey.maxDeputyTask] = 1;
    static [ConfigKey.maxCirculateTask] = 0;
    static [ConfigKey.maxForeverTask] = 30;


    // 多少级开启存档功能
    static [ConfigKey.storeLevel] = 0;

    // 玩家使用命令获取工具时生成uuid的位数  配合tool文件夹下的加密工具使用
    static [ConfigKey.uuidNum] = 5;

    // 换皮配置
    // gameInit中初始化环境时  1是全亮 0是有迷雾
    static [ConfigKey.flog] = 1;

    // UI开关
    // getGoodTrigger中拾取装备时，初始化gui时隐藏背包按钮
    static [ConfigKey.useGoodsBar] = 1;
    // 任务面板在下列情况下刷新 taskController 中 applyTask  与  recordNum
    static [ConfigKey.useTaskBar] = 1;
    // 是否使用成就面板
    static [ConfigKey.useAchBar] = 1;
    // 是否使用宠物面板
    static [ConfigKey.usePetBar] = 1;
    // 是否使用右上角多面板
    static [ConfigKey.useMultiBoradBar] = 1;

    // 是否使用选择难度面板
    static [ConfigKey.useDiffBar] = 1;

    // 是否使用聊天框
    static [ConfigKey.useChatBar] = 1;

    // 是否使用天赋面板 并且 是否使用 天赋三选一
    static [ConfigKey.useTalentBar] = 1;
    // 选择成就的等级间隔
    static [ConfigKey.levelUpInterval] = 1;
    // 选择成就面板跳出几个成就
    static [ConfigKey.chooseOneNum] = 3;


    // 是否使用选择英雄面板
    static [ConfigKey.useChooseHeroBar] = 1;
    // 是否使用查看英雄属性面板
    static [ConfigKey.useAttrBar] = 1;
    // 是否伤害面板
    static [ConfigKey.useDamageBar] = 1;
    // 是否使用羁绊功能
    static [ConfigKey.useCombination] = 1;
    // 是否使用图鉴功能
    static [ConfigKey.useHandBook] = 1;
    // 是否使用外观功能
    static [ConfigKey.useAppearance] = 1;
    // 是否使用UI商城
    static [ConfigKey.useIntegralMall] = 1;
    // 是否使用隐藏成就
    static [ConfigKey.useHideAch] = 1;
    // 是否使用单位属性面板
    static [ConfigKey.useUnitAttrBar] = 1;


    // gameInit中是否同时创建箱子宠物
    static [ConfigKey.useBox] = 0;


    // 使用品质合成
    static [ConfigKey.useQualityMix] = 0;

    // 使用物品栏装备部位检查
    static [ConfigKey.usePositionCheck] = 1;
    // 宠物跟随
    static [ConfigKey.petPatro] = 1;
    // 宠物被捕捉后是否自动跟随
    static [ConfigKey.autoPetPatro] = 0;
    // 宠物被捕捉后是否自动召唤
    static [ConfigKey.autoPetCall] = 0;
    // 宠物召唤类型
    static [ConfigKey.petCallType] = PetCallType.home;
    // 死亡后自动复活
    static [ConfigKey.petResumeType] = PetResumeType.default;
    // 超过距离传送
    static [ConfigKey.outRangeMove] = 1000;

    // 宠物巡逻范围
    static [ConfigKey.patrolRange] = 500;

    // 获得物品时绑定物品所有权
    static [ConfigKey.bindItemBlong] = 0;

    // 胜利与失败的延迟时间
    static [ConfigKey.winDelay] = 10;
    static [ConfigKey.failDelay] = 10

    // n波胜利后开启无尽模式
    static [ConfigKey.hentaiDifficulty] = 0;

    // 使用技能书时启用技能家族学习逻辑
    static [ConfigKey.learnSkillByFamilyId] = 1;

    // 是否启用玩家死亡时自动复活
    static [ConfigKey.resumeTypes]: number[] = [ResumeType.autoResume];
    // 英雄默认的复活时间
    static [ConfigKey.resumeTime] = 60;

    // 初始英雄随机数量 大于1时启用选择英雄UI面板
    static [ConfigKey.initheroAmount] = 1;

    // 出怪时是否自动出下一波怪
    static [ConfigKey.waveAuto] = 1
    // 生存表漂浮文字大小
    static [ConfigKey.baseTextSize] = 15


    /*
        毒圈相关设置
     */
    // 是否启动毒圈
    static [ConfigKey.poison] = 0;
    // 毒圈伤害的基数
    static [ConfigKey.poisonCardinal] = 5;
    // 毒圈伤害的因子
    static [ConfigKey.poisonDivisor] = 1;
    // 毒圈伤害特效点
    static [ConfigKey.poisonEffectPoint] = 'origin';
    // 毒圈伤害特效
    static [ConfigKey.poisonEffect] = 'Abilities\\Weapons\\PoisonSting\\PoisonStingTarget.mdl';
    // 毒圈伤害是否使用百分比伤害
    static [ConfigKey.poisonUsePercent] = 1;


    /*
        地图初始化设置
    */
    // 是否开启时间流逝
    static [ConfigKey.timeScale] = 0;
    // 游戏如果从白天开始 从几点开始
    static [ConfigKey.dayStartTime] = 12;
    // 游戏如果从夜间开始 从几点开始
    static [ConfigKey.nightStartTime] = 18;
    // 开启日夜轮转
    static [ConfigKey.dayNightTurn] = 1;
    // 游戏是否从夜间开始（默认从白天开始）
    static [ConfigKey.startInNight] = 0;

    /*
        复活相关设置
     */
    // 是否开启自动复活
    static [ConfigKey.autoResumeAll] = 0;
    // 自动复活的延迟时间（比如游戏开始后300秒后才开启复活倒计时）
    static [ConfigKey.resumeAllDelay] = 300;
    // 自动复活的读秒时间
    static [ConfigKey.resumeAllTime] = 300;
    // 出boss的剑阁
    static [ConfigKey.bossInterval] = 180;

    // 难度根据玩家人物增强的基数
    static [ConfigKey.diffRadixByPlayerNum] = [
        1,
        1,
        1,
        1,
        1,
        1,
    ];
    // 幸运根据玩家人物增强的基数
    static [ConfigKey.luckyRadixByPlayerNum] = [
        1,
        1,
        1,
        1,
        1,
        1,
    ];
    // 幸运根据玩家人物增强的基数
    static [ConfigKey.expRadixByPlayerNum] = [
        4,
        2,
        1,
        1,
        1,
        1,
    ];
    // boss根据剩余boss变强的基数（剩余一个boss时取第一位，剩余两个boss时取第二位）
    static [ConfigKey.diffRadixByBossNum] = [];


    // 脱战倒计时
    static [ConfigKey.removeFightTime] = 10;

    // 经验奖励范围
    static [ConfigKey.expRange] = 900;

    // 经验共享方式
    static [ConfigKey.expType] = ExpShareType.share;

    // 经验衰减比例百分数
    static [ConfigKey.attenuation] = 20;

    // 经验最大衰减百分数
    static [ConfigKey.maxAttenuation] = 50;

    // 背包数量 修改这个设置时需要同时修改代码  否则会造成超出部分背包不能保存
    static [ConfigKey.maxItemIndex] = 2;

    // 打开本开关时，击杀boss会将boss的掉落物刷新在玩家的起始点;
    static [ConfigKey.useBossRewardLoc] = 0;


    // 是否检测游戏独自胜利(对战图)
    static [ConfigKey.checkGameWinAlone] = 0;

    // 检测失败的倒计时
    static [ConfigKey.checkLoseTime] = 10;

    // 掉落物品以矩形排开
    static [ConfigKey.dropSpace] = 100;

    // 打开本开关时，击杀boss会将boss的掉落物刷新在玩家的起始点;
    static [ConfigKey.protection] = 5;

    // 单位死亡后清除单位的时间
    static [ConfigKey.clearUnitTime] = 1;

    // 重铸装备成功几率 装备提升一级
    static [ConfigKey.resetGoodSuccess] = 20;

    // 重铸装备失败几率 装备降低一级
    static [ConfigKey.resetGoodFailed] = 5;

    static [ConfigKey.maxLowTimerExeNum] = 1;

    static [ConfigKey.maxLowTimerExeNum] = 1;

    static [ConfigKey.winScore] = 1000;

    static [ConfigKey.unitUseFamily] = 1;

    static [ConfigKey.itemUseFamily] = 0;

    static [ConfigKey.unitUseLadder] = 0;

    static [ConfigKey.itemUseLadder] = 1;

    static [ConfigKey.maxUnitFamily] = 9;

    static [ConfigKey.maxCombinationMemberNum] = 5;

    static [ConfigKey.leaveFightReset] = 1;

    static [ConfigKey.petDead] = 0;

    static [ConfigKey.maxButtonNum] = 6;

    static [ConfigKey.maxLevelUpNum] = 180;

    static [ConfigKey.maxIntegral] = 99;

    static [ConfigKey.showHurtNum] = 1;

    static [ConfigKey.storeSplit] = '';

    static [ConfigKey.initCoin] = 0;
    static [ConfigKey.initWood] = 0;
    static [ConfigKey.initHeight] = 2500;
    static [ConfigKey.initAngle] = 304;

    static [ConfigKey.resetAllUnit] = 1;
    static [ConfigKey.useInputBackHome] = 1;
    static [ConfigKey.useF2BackHome] = 1;
    static [ConfigKey.useDSan] = 0;

    static [ConfigKey.maxEncryptedLockKeyLen] = 10;

    static [ConfigKey.reflushPath] = 10;
    static [ConfigKey.reflushHatred] = 10;

    static [ConfigKey.talkTaskRange] = 200;

    static [ConfigKey.autoClearHurtNum] = 1;

    static [ConfigKey.autoShowAllHero] = 0;

    static [ConfigKey.integralBase] = 6;

    static [ConfigKey.engulfPetSkillRadix] = 1;

    static [ConfigKey.maxUIShopNum] = 12;

    static [ConfigKey.awaitWave] = 0;

    static [ConfigKey.autoOpenDamage] = 1;
    static [ConfigKey.autoOpenTask] = 1;

    static [ConfigKey.initExp] = 0;
    static [ConfigKey.expBase] = 1000;

    static [ConfigKey.sellItemRange] = 500;

    static [ConfigKey.signalDurition]: number = 5;

    static [ConfigKey.maxChatsLen]: number = 30;
    static [ConfigKey.maxToastLen]: number = 10;

    static [ConfigKey.cameraUnit]: number = 500;
    static [ConfigKey.maxCameraHeight]: number = 4000;
    static [ConfigKey.minCameraHeight]: number = 900;

    static [ConfigKey.showTimeDialog]: number = 0;

    static [ConfigKey.syncInterval]: number = 0.01;

    static [ConfigKey.maxArchiveNum]: number = 2;

    static [ConfigKey.maxStoreNum]: number = 140;

    static [ConfigKey.useLockKey]: number = 0;

    static [ConfigKey.talentMaxNum]: number = 5;

    static [ConfigKey.attrSetting]: { [key: number]: AttrSetting } = {

        // 力量
        [AttributeEnum.strength]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '力量',
            suffix: '',
        },
        // 敏捷
        [AttributeEnum.agile]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '敏捷',
            suffix: '',
        },
        // 智力
        [AttributeEnum.intellect]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '智力',
            suffix: '',
        },
        // 生命值
        [AttributeEnum.life]: {
            fightValue: FightBaseValueLevel.null,
            name: '生命',
            suffix: '',
        },
        // 最大生命值
        [AttributeEnum.maxLife]: {
            fightValue: FightBaseValueLevel.tooLower,
            name: '生命值',
            suffix: '',
        },
        // 生命回复速度
        [AttributeEnum.lifeRecovery]: {
            fightValue: FightBaseValueLevel.lower,
            name: '生命回复',
            suffix: '',
        },
        // 魔法值
        [AttributeEnum.magic]: {
            fightValue: FightBaseValueLevel.null,
            name: '魔法',
            suffix: '',
        },
        // 最大魔法值
        [AttributeEnum.maxMagic]: {
            fightValue: FightBaseValueLevel.tooLower,
            name: '魔法值',
            suffix: '',
        },
        // 魔法恢复速度
        [AttributeEnum.magicRecovery]: {
            fightValue: FightBaseValueLevel.lower,
            name: '魔法回复',
            suffix: '',
        },
        // 护甲
        [AttributeEnum.defense]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '物理防御',
            suffix: '',
        },
        // 攻击力
        [AttributeEnum.attack]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '攻击力',
            suffix: '',
        },
        // 攻击速度
        [AttributeEnum.attackSpeed]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '攻击速度',
            suffix: '',
        },
        // 攻击范围
        [AttributeEnum.attackRange]: {
            fightValue: FightBaseValueLevel.null,
            name: '溅射范围',
            suffix: '',
        },

        // 物理暴击伤害
        [AttributeEnum.CH_physics_hurt]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '物理暴击伤害',
            suffix: '%',
        },
        // 物理暴击率
        [AttributeEnum.CH_physics_chance]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '物理暴击几率',
            suffix: '%',
        },
        // 物理加成
        [AttributeEnum.physicsAddRadix]: {
            fightValue: FightBaseValueLevel.mid,
            name: '物理伤害加成',
            suffix: '%',
        },
        // 物理伤害减免 最终伤害减免  不受任何穿透影响
        [AttributeEnum.physics_damage_reduction]: {
            fightValue: FightBaseValueLevel.mid,
            name: '物理伤害减免',
            suffix: '%',
        },
        // 物理吸血
        [AttributeEnum.physics_blood_sucking]: {
            fightValue: FightBaseValueLevel.mid,
            name: '物理吸血',
            suffix: '%',
        },
        // 物理命中
        [AttributeEnum.physics_hit]: {
            fightValue: FightBaseValueLevel.low,
            name: '物理命中',
            suffix: '',
        },
        // 物理闪避
        [AttributeEnum.physics_Dodge]: {
            fightValue: FightBaseValueLevel.low,
            name: '物理闪避',
            suffix: '',
        },

        // 法术暴击伤害
        [AttributeEnum.CH_spell_hurt]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '法术暴击伤害',
            suffix: '%',
        },
        // 法术暴击率
        [AttributeEnum.CH_spell_chance]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '法术暴击几率',
            suffix: '%',
        },
        // 法术加成
        [AttributeEnum.spellAddRadix]: {
            fightValue: FightBaseValueLevel.mid,
            name: '法术伤害加成',
            suffix: '%',
        },
        // 法术伤害减免 最终伤害减免  不受任何穿透影响
        [AttributeEnum.spell_damage_reduction]: {
            fightValue: FightBaseValueLevel.mid,
            name: '法术伤害减免',
            suffix: '%',
        },
        // 法术吸血
        [AttributeEnum.spell_blood_sucking]: {
            fightValue: FightBaseValueLevel.mid,
            name: '法术吸血',
            suffix: '%',
        },
        // 法术命中
        [AttributeEnum.spell_hit]: {
            fightValue: FightBaseValueLevel.low,
            name: '法术命中',
            suffix: '',
        },
        // 法术闪避
        [AttributeEnum.spell_Dodge]: {
            fightValue: FightBaseValueLevel.low,
            name: '法术闪避',
            suffix: '',
        },

        // 移动速度
        [AttributeEnum.speed]: {
            fightValue: FightBaseValueLevel.null,
            name: '移动速度',
            suffix: '',
        },

        // 幸运值
        [AttributeEnum.luckyValue]: {
            fightValue: FightBaseValueLevel.null,
            name: '幸运',
            suffix: '',
        },
        // 金币
        [AttributeEnum.coin]: {
            fightValue: FightBaseValueLevel.null,
            name: '金币',
            suffix: '',
        },
        // 金币加成
        [AttributeEnum.coinAddRadix]: {
            fightValue: FightBaseValueLevel.null,
            name: '金币获取',
            suffix: '%',
        },
        // 木头
        [AttributeEnum.wood]: {
            fightValue: FightBaseValueLevel.null,
            name: '木头',
            suffix: '',
        },
        // 木头加成
        [AttributeEnum.woodAddRadix]: {
            fightValue: FightBaseValueLevel.null,
            name: '木头获取',
            suffix: '%',
        },
        // 经验
        [AttributeEnum.exp]: {
            fightValue: FightBaseValueLevel.null,
            name: '经验',
            suffix: '',
        },
        // 经验加成
        [AttributeEnum.expAddRadix]: {
            fightValue: FightBaseValueLevel.null,
            name: '经验获取',
            suffix: '%',
        },


        // 攻击距离
        [AttributeEnum.attackDistance]: {
            fightValue: FightBaseValueLevel.low,
            name: '攻击距离',
            suffix: '',
        },
        // 体型
        [AttributeEnum.size]: {
            fightValue: FightBaseValueLevel.null,
            name: '体积',
            suffix: '',
        },
        // 冷却缩减
        [AttributeEnum.coolingReduction]: {
            fightValue: FightBaseValueLevel.max,
            name: '技能急速',
            suffix: '',
        },

        // 主属性
        [AttributeEnum.mainAttr]: {
            fightValue: FightBaseValueLevel.low,
            name: '主属性',
            suffix: '',
        },

        // 物理穿透 只穿透抗性
        [AttributeEnum.physics_Penetration]: {
            fightValue: FightBaseValueLevel.mid,
            name: '护甲穿透',
            suffix: '%',
        },
        // 法术穿透 只穿透抗性
        [AttributeEnum.spell_Penetration]: {
            fightValue: FightBaseValueLevel.mid,
            name: '法术穿透',
            suffix: '%',
        },

        // 物理反伤
        [AttributeEnum.physics_Thorns]: {
            fightValue: FightBaseValueLevel.mid,
            name: '物理反伤',
            suffix: '%',
        },
        // 法术反伤
        [AttributeEnum.spell_Thorns]: {
            fightValue: FightBaseValueLevel.mid,
            name: '法术反伤',
            suffix: '%',
        },
        // 捕捉概率补偿
        [AttributeEnum.catchRadix]: {
            fightValue: FightBaseValueLevel.null,
            name: '捕获概率',
            suffix: '%',
        },

        // 百分比增幅主属性
        [AttributeEnum.mainAttrP]: {
            fightValue: FightBaseValueLevel.null,
            name: '主属性',
            suffix: '%',
        },
        // 力量百分比
        [AttributeEnum.strP]: {
            fightValue: FightBaseValueLevel.null,
            name: '力量',
            suffix: '%',
        },
        // 敏捷百分比
        [AttributeEnum.agiP]: {
            fightValue: FightBaseValueLevel.null,
            name: '敏捷',
            suffix: '%',
        },
        // 智力百分比
        [AttributeEnum.intP]: {
            fightValue: FightBaseValueLevel.null,
            name: '智力',
            suffix: '%',
        },
        // 溅射伤害
        [AttributeEnum.attackRangeHurt]: {
            fightValue: FightBaseValueLevel.null,
            name: '溅射伤害',
            suffix: '%',
        },
        // 技能效果增强
        [AttributeEnum.abilityBonus]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '技能效果增强',
            suffix: '%',
        },
        // 法强
        [AttributeEnum.law]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '法术强度',
            suffix: '',
        },
        // 真实伤害
        [AttributeEnum.realHurt]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '真实伤害',
            suffix: '',
        },
        // 百分比真实伤害
        [AttributeEnum.realHurtP]: {
            fightValue: FightBaseValueLevel.null,
            name: '真实伤害',
            suffix: '%',
        },
        // 百分比攻击力
        [AttributeEnum.attackP]: {
            fightValue: FightBaseValueLevel.null,
            name: '攻击力',
            suffix: '%',
        },
        // 百分比法强
        [AttributeEnum.lawP]: {
            fightValue: FightBaseValueLevel.null,
            name: '法术强度',
            suffix: '%',
        },
        // 攻击间隔
        [AttributeEnum.attackSpeedInterval]: {
            fightValue: FightBaseValueLevel.negative,
            name: '攻击间隔',
            suffix: '',
        },
        // 总伤害加成
        [AttributeEnum.allAddRadix]: {
            fightValue: FightBaseValueLevel.high,
            name: '最终伤害加成',
            suffix: '%',
        },
        // boss伤害加成
        [AttributeEnum.bossAddRadix]: {
            fightValue: FightBaseValueLevel.null,
            name: 'boss伤害加成',
            suffix: '%',
        },
        // 小怪伤害加成
        [AttributeEnum.monsterAddRadix]: {
            fightValue: FightBaseValueLevel.null,
            name: '小怪伤害加成',
            suffix: '%',
        },
        // 魔法抗性
        [AttributeEnum.magicResistance]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '魔法防御',
            suffix: '',
        },
        // 百分比最大生命值
        [AttributeEnum.maxLifeP]: {
            fightValue: FightBaseValueLevel.null,
            name: '最大生命值回复',
            suffix: '%',
        },
        // 百分比最大魔法值
        [AttributeEnum.maxMagicP]: {
            fightValue: FightBaseValueLevel.null,
            name: '最大魔法值回复',
            suffix: '%',
        },
        // 百分比物理防御
        [AttributeEnum.defenseP]: {
            fightValue: FightBaseValueLevel.null,
            name: '物理防御',
            suffix: '%',
        },
        // 百分比魔法抗性
        [AttributeEnum.magicResistanceP]: {
            fightValue: FightBaseValueLevel.null,
            name: '魔法防御',
            suffix: '%',
        },
        // 百分比生命恢复
        [AttributeEnum.lifeRecoveryP]: {
            fightValue: FightBaseValueLevel.null,
            name: '生命回复',
            suffix: '%',
        },
        // 总伤害免疫
        [AttributeEnum.allDamageReduction]: {
            fightValue: FightBaseValueLevel.high,
            name: '总伤害免疫',
            suffix: '%',
        },
        // 物理暴击抵抗
        [AttributeEnum.CH_physics_Resistance]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '物理暴击抵抗',
            suffix: '',
        },
        // 魔法暴击抵抗
        [AttributeEnum.CH_spell_Resistance]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '魔法暴击抵抗',
            suffix: '',
        },
        // 技能触发几率
        [AttributeEnum.skillProbability]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '技能触发几率',
            suffix: '%',
        },
        // 百分比魔法恢复
        [AttributeEnum.magicRecoveryP]: {
            fightValue: FightBaseValueLevel.null,
            name: '魔法回复',
            suffix: '%',
        },
        // 物理格挡
        [AttributeEnum.physicsDamageBlock]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '物理格挡',
            suffix: '',
        },
        // 魔法格挡
        [AttributeEnum.spellDamageBlock]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '魔法格挡',
            suffix: '',
        },
        // 物理精准
        [AttributeEnum.physicsPrecise]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '物理精准',
            suffix: '',
        },
        // 魔法精准
        [AttributeEnum.spellPrecise]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '魔法精准',
            suffix: '',
        },
        // 控制抗性
        [AttributeEnum.controlResistance]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '控制抗性',
            suffix: '',
        },
        // 百分比生命恢复
        [AttributeEnum.lifeRecoveryMaxP]: {
            fightValue: FightBaseValueLevel.mid,
            name: '生命回复',
            suffix: '%',
        },
        // 百分比魔法恢复
        [AttributeEnum.magicRecoveryMaxP]: {
            fightValue: FightBaseValueLevel.mid,
            name: '魔法回复',
            suffix: '%',
        },
        // 每秒攻击力
        [AttributeEnum.attackInterval]: {
            fightValue: FightBaseValueLevel.null,
            name: '每秒攻击力',
            suffix: '',
        },
        // 每秒力量
        [AttributeEnum.strInterval]: {
            fightValue: FightBaseValueLevel.null,
            name: '每秒力量',
            suffix: '',
        },
        // 每秒敏捷
        [AttributeEnum.agiInterval]: {
            fightValue: FightBaseValueLevel.null,
            name: '每秒敏捷',
            suffix: '',
        },
        // 每秒智力
        [AttributeEnum.intInterval]: {
            fightValue: FightBaseValueLevel.null,
            name: '每秒智力',
            suffix: '',
        },
        // 每秒金币
        [AttributeEnum.coinInterval]: {
            fightValue: FightBaseValueLevel.null,
            name: '每秒金币',
            suffix: '',
        },
        // 每秒木材
        [AttributeEnum.woodInterval]: {
            fightValue: FightBaseValueLevel.null,
            name: '每秒木材',
            suffix: '',
        },
        // 每秒最大生命值
        [AttributeEnum.maxLifeInterval]: {
            fightValue: FightBaseValueLevel.null,
            name: '每秒最大生命值',
            suffix: '',
        },
        // 每秒最大魔法值
        [AttributeEnum.maxMagicInterval]: {
            fightValue: FightBaseValueLevel.null,
            name: '每秒最大魔法值',
            suffix: '',
        },
        // 固定物理减免
        [AttributeEnum.regular_physics_damage_reduction]: {
            fightValue: FightBaseValueLevel.mid,
            name: '物理伤害减免',
            suffix: '',
        },
        // 固定魔法减免
        [AttributeEnum.regular_spell_damage_reduction]: {
            fightValue: FightBaseValueLevel.mid,
            name: '魔法伤害减免',
            suffix: '',
        },
        // 固定物理穿透
        [AttributeEnum.regular_physics_Penetration]: {
            fightValue: FightBaseValueLevel.mid,
            name: '护甲穿透',
            suffix: '',
        },
        // 固定魔法穿透
        [AttributeEnum.regular_spell_Penetration]: {
            fightValue: FightBaseValueLevel.mid,
            name: '法术穿透',
            suffix: '',
        },
        // 溅射角度
        [AttributeEnum.attackRangeAngle]: {
            fightValue: FightBaseValueLevel.null,
            name: '溅射角度',
            suffix: '%',
        },
        // 治疗加成
        [AttributeEnum.treatAddRadix]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '治疗加成',
            suffix: '%',
        },
        // 治疗暴击
        [AttributeEnum.CH_treat_hurt]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '治疗暴击',
            suffix: '%',
        },
        // 治疗暴击几率
        [AttributeEnum.CH_treat_chance]: {
            fightValue: FightBaseValueLevel.nomal,
            name: '治疗暴击几率',
            suffix: '%',
        },
        // 治疗抗性（重伤）
        [AttributeEnum.treatResistance]: {
            fightValue: FightBaseValueLevel.negative,
            name: '重伤',
            suffix: '',
        },
        // 治疗穿透
        [AttributeEnum.treatPenetration]: {
            fightValue: FightBaseValueLevel.mid,
            name: '治疗穿透',
            suffix: '',
        },
        // 治疗减免
        [AttributeEnum.treat_damage_reduction]: {
            fightValue: FightBaseValueLevel.mid,
            name: '治疗减免',
            suffix: '%',
        },
        [AttributeEnum.al_chHurt]: {
            fightValue: FightBaseValueLevel.mid,
            name: '暴击伤害',
            suffix: '%',
        },
        [AttributeEnum.al_chChance]: {
            fightValue: FightBaseValueLevel.mid,
            name: '暴击几率',
            suffix: '%',
        },
        [AttributeEnum.al_hurtAddRadix]: {
            fightValue: FightBaseValueLevel.mid,
            name: '伤害加成',
            suffix: '%',
        },
        [AttributeEnum.al_blood_sucking]: {
            fightValue: FightBaseValueLevel.mid,
            name: '吸血',
            suffix: '%',
        },
        [AttributeEnum.al_hit]: {
            fightValue: FightBaseValueLevel.mid,
            name: '命中',
            suffix: '',
        },
        [AttributeEnum.al_regular_Penetration]: {
            fightValue: FightBaseValueLevel.mid,
            name: '穿透',
            suffix: '',
        },
        [AttributeEnum.al_penetration]: {
            fightValue: FightBaseValueLevel.mid,
            name: '穿透',
            suffix: '%',
        },
        [AttributeEnum.al_precise]: {
            fightValue: FightBaseValueLevel.mid,
            name: '精准',
            suffix: '',
        },
        [AttributeEnum.al_dodge]: {
            fightValue: FightBaseValueLevel.mid,
            name: '闪避',
            suffix: '',
        },
        [AttributeEnum.al_damageBlock]: {
            fightValue: FightBaseValueLevel.mid,
            name: '格挡',
            suffix: '%',
        },
        [AttributeEnum.al_chResistance]: {
            fightValue: FightBaseValueLevel.mid,
            name: '暴击抵抗',
            suffix: '%',
        },
        [AttributeEnum.al_thorns]: {
            fightValue: FightBaseValueLevel.mid,
            name: '反伤',
            suffix: '%',
        },
        [AttributeEnum.al_regularDamageReduction]: {
            fightValue: FightBaseValueLevel.mid,
            name: '伤害减免',
            suffix: '',
        },
        [AttributeEnum.al_damageReduction]: {
            fightValue: FightBaseValueLevel.mid,
            name: '伤害减免',
            suffix: '%',
        },
    }

    static [ConfigKey.washSetting]: CosumeSetting = { success: 30, failed: 10, cosumeId: '', cosumeNum: 1 }
    static [ConfigKey.forgSetting]: (CosumeSetting & { decomposeId: string })[] = [
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
        { success: 30, failed: 10, cosumeId: '', cosumeNum: 1, decomposeId: '' },
    ];
    static [ConfigKey.qualitySetting]: QualitySetting[] = [
        {
            name: '破旧',
            mixNum: 3,
            decomposeId: '',
            lvBox: '',
        },
        {
            name: '劣质',
            mixNum: 3,
            decomposeId: '',
            lvBox: '',
        },
        {
            name: '瑕疵',
            mixNum: 3,
            decomposeId: '',
            lvBox: '',
        },
        {
            name: '普通',
            mixNum: 3,
            decomposeId: '',
            lvBox: 'si03',
        },
        {
            name: '优秀',
            mixNum: 3,
            decomposeId: '',
            lvBox: 'si04',
        },
        {
            name: '精良',
            mixNum: 3,
            decomposeId: '',
            lvBox: 'si05',
        },
        {
            name: '史诗',
            mixNum: 3,
            decomposeId: '',
            lvBox: 'si06',
        },
        {
            name: '传说',
            mixNum: 3,
            decomposeId: '',
            lvBox: 'si07',
        },
    ];
    static [ConfigKey.forgAddRadix] = 0.2;

    static [ConfigKey.attackedEffectScale] = 0;

    static [ConfigKey.callPetLvLimit] = 5;

    // key 是等级相差百分比，value 是获取经验百分比
    static [ConfigKey.expAttenuation]: ExpAttenuationSetting = {
        20: 0,
        10: 0.1,
        5: 0.5,
    };
}